//package cn.genmer.test.security.gdzbphback;
//
//import com.alibaba.fastjson.JSON;
//import com.teleware.gdzbphdtjg.common.CommonResult;
//import com.teleware.gdzbphdtjg.model.*;
//import com.teleware.gdzbphdtjg.service.*;
//import com.teleware.gdzbphdtjg.utils.FileUtil;
//import com.teleware.gdzbphdtjg.utils.XmlParserUtils;
//import com.webservice.DataExportService;
//import com.webservice.DataExportService2;
//import com.webservice.DataExportService2Soap;
//import com.webservice.DataExportServiceSoap;
//import io.swagger.annotations.Api;
//import io.swagger.annotations.ApiOperation;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.util.CollectionUtils;
//import org.springframework.web.bind.annotation.GetMapping;
//import org.springframework.web.bind.annotation.RequestMapping;
//import org.springframework.web.bind.annotation.RestController;
//
//import java.io.*;
//import java.util.*;
//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.Executors;
//
//@RestController
//@Api(tags = "测试服务 - 备份")
//@RequestMapping("/rest/projectinfo/import")
//public class DataImportController {
//
//    private static final String basePath = "D:\\program\\work\\hbdata";
//
//    @Autowired
//    private JSXMService jsxmService;
//
//    @Autowired
//    private JSXM_XZQBMService jsxm_xzqbmService;
//
//    @Autowired
//    private ZBGXService zbgxService;
//
//    @Autowired
//    private BJBService bjbService;
//
//    @Autowired
//    private ZBGXGZService zbgxgzService;
//
//    @Autowired
//    private ZBHXService zbhxService;
//
//    @Autowired
//    private ZBCNHXService zbcnhxService;
//
//    @Autowired
//    private ZBCNDXService zbcndxService;
//
//    @Autowired
//    private RATIFYLOGService ratifylogService;
//
//    @Autowired
//    private ZBYJService zbyjService;
//
//    @Autowired
//    private ZBTJService zbtjService;
//
//    @Autowired
//    private ZBQTService zbqtService;
//
//    @Autowired
//    private ZBDJService zbdjService;
//
//    @Autowired
//    private GJTCORDERService gjtcorderService;
//
//    @Autowired
//    private GJTCITEMSService gjtcitemsService;
//
//    @Autowired
//    private SQMXService sqmxService;
//
//    @Autowired
//    private HC_JDYSService jdysService;
//
//    @Autowired
//    private SCXMLOGService scxmlogService;
//
//    @Autowired
//    private ZBCNService zbcnService;
//
//    @Value("${hb-gdzbphdtjg.api.username:}")
//    private String username;
//
//    @Value("${hb-gdzbphdtjg.api.password:}")
//    private String password;
//
//    @Value("${hb-gdzbphdtjg.api.xzqdm:}")
//    private String xzqdm;
//
//    @Value("${hb-gdzbphdtjg.construction.start-time}")
//    private String startTime;
//
//    @Value("${hb-gdzbphdtjg.construction.end-time}")
//    private String endTime;
//
//    @Value("${hb-gdzbphdtjg.waring.year:2018}")
//    private String year;
//
//    @Value("${hb-gdzbphdtjg.countries-as-whole-application.last-time}")
//    private String lastTime;
//
//    @ApiOperation("2.1、导入项目建设信息")
//    @GetMapping("/construction")
//    public String construction(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取前置信息 - 确认信息号
//        String JSXMByTime = client.exportJSXMByTime(username, password, xzqdm, startTime,endTime);
//        // 对原始结果进行处理
//        String xmlContent = XmlParserUtils.getXMLContent(JSXMByTime);
//        if (xmlContent.substring(0,1).equalsIgnoreCase(":")){
//            System.out.println(String.format("[根据上报时间导出建设项目指定信息 string]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[根据上报时间导出建设项目指定信息]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        // 生成临时文件地址
//        String filename = "[临时文件]" + UUID.randomUUID().toString();
//        String url = XmlParserUtils.generateFile(xmlContent, basePath, filename, ".xml");
//        // 创建结果集列表
//        ArrayList<B_JSXM> jsxmList = new ArrayList<>();
//        ArrayList<B_JSXM_XZQBM> jsxmXzqbmList = new ArrayList<>();
//        ArrayList<B_ZBGX> zbgxList = new ArrayList<>();
//        ArrayList<B_BJB> bjbList = new ArrayList<>();
//        ArrayList<B_RATIFYLOG> ratifylogs = new ArrayList<>();
//        ArrayList<B_ZBGXGZ> zbgxgzs = new ArrayList<>();
//        ArrayList<B_ZBHX> zbhxes = new ArrayList<>();
//        ArrayList<B_ZBCNDX> zbcndxes = new ArrayList<>();
//        ArrayList<B_ZBCNHX> zbcnhxes = new ArrayList<>();
//        try {
//            // 从生成的xml文件中获取数据 - 结束后会删除缓存文件
//            ArrayList<String> qrxxhList = XmlParserUtils.getParameterPrefix(url,"JSXMBASIC_DTOs","JSXM_QRXX");
//            if (CollectionUtils.isEmpty(qrxxhList)){
//                return "获取前置信息出错！";
//            }
//            for (String qrxxh: qrxxhList){
//                // 根据确认信息号，获取对应的项目信息
//                String jsxm1 = client.exportJSXM(username, password, xzqdm, qrxxh);
//                Map jsxmData = XmlParserUtils.getJSXMData(jsxm1, "DataPackage",
//                        "B_JSXM_DTO,B_BJB_DTO",
//                        "B_JSXM_XZQBM_DTOs,B_ZBGX_DTOs,B_ZBGXGZ_DTOs,B_ZBHX_DTOs,B_ZBCNHX_DTOs,B_ZBCNDX_DTOs,B_RATIFYLOG_DTOs");
//                // 获取项目信息数据
//                Map<String, Object> b_jsxm_dto = (Map) jsxmData.get("B_JSXM_DTO");
//                Map<String, Object> b_bjb_dto = (Map) jsxmData.get("B_BJB_DTO");
//                // 获取项目信息中的子类数据 - jsxm
//                if (isValueExist(b_jsxm_dto, "B_ZBGX_DTOs", "B_ZBGX_DTO")){
//                    Map zbgx_dtOs = (Map) b_jsxm_dto.get("B_ZBGX_DTOs");
//                    Map zbgx_dtO = (Map) zbgx_dtOs.get("B_ZBGX_DTO");
//                    B_ZBGX b_zbgx = JSON.parseObject(JSON.toJSONString(zbgx_dtO), B_ZBGX.class);
//                    zbgxList.add(b_zbgx);
//                }
//                if (isValueExist(b_jsxm_dto, "B_JSXM_XZQBM_DTOs", "B_JSXM_XZQBM_DTO")){
//                    Map xzqbm_dtOs = (Map) b_jsxm_dto.get("B_JSXM_XZQBM_DTOs");
//                    Map xzqbm_dto = (Map) xzqbm_dtOs.get("B_JSXM_XZQBM_DTO");
//                    B_JSXM_XZQBM b_jsxm_xzqbm = JSON.parseObject(JSON.toJSONString(xzqbm_dto), B_JSXM_XZQBM.class);
//                    jsxmXzqbmList.add(b_jsxm_xzqbm);
//                }
//                if (isValueExist(b_jsxm_dto, "B_ZBGXGZ_DTOs", "B_ZBGXGZ_DTO")){
//                    Map zbgxgz_dtOs = (Map) b_jsxm_dto.get("B_ZBGXGZ_DTOs");
//                    Map zbgxgz_dtO = (Map) zbgxgz_dtOs.get("B_ZBGXGZ_DTO");
//                    B_ZBGXGZ zbgxgz = JSON.parseObject(JSON.toJSONString(zbgxgz_dtO), B_ZBGXGZ.class);
//                    zbgxgzs.add(zbgxgz);
//                }
//                if (isValueExist(b_jsxm_dto, "B_ZBHX_DTOs", "B_ZBHX_DTO")){
//                    Map zbhx_dtOs = (Map) b_jsxm_dto.get("B_ZBHX_DTOs");
//                    Map zbhx_dtO = (Map) zbhx_dtOs.get("B_ZBHX_DTO");
//                    B_ZBHX zbhx = JSON.parseObject(JSON.toJSONString(zbhx_dtO), B_ZBHX.class);
//                    zbhxes.add(zbhx);
//                }
//                if (isValueExist(b_jsxm_dto, "B_ZBCNHX_DTOs", "B_ZBCNHX_DTO")){
//                    Map zbcnhx_dtOs = (Map) b_jsxm_dto.get("B_ZBCNHX_DTOs");
//                    Map zbcnhx_dto = (Map) zbcnhx_dtOs.get("B_ZBCNHX_DTO");
//                    B_ZBCNHX zbcnhx = JSON.parseObject(JSON.toJSONString(zbcnhx_dto), B_ZBCNHX.class);
//                    zbcnhxes.add(zbcnhx);
//                }
//                if (isValueExist(b_jsxm_dto, "B_ZBCNDX_DTOs", "B_ZBCNDX_DTO")){
//                    Map zbcndx_dtOs = (Map) b_jsxm_dto.get("B_ZBCNDX_DTOs");
//                    Map zbcndx_dto = (Map) zbcndx_dtOs.get("B_ZBCNDX_DTO");
//                    B_ZBCNDX zbcndx = JSON.parseObject(JSON.toJSONString(zbcndx_dto), B_ZBCNDX.class);
//                    zbcndxes.add(zbcndx);
//                }
//                // 获取项目信息中的子类数据 - bjb
//                if (isValueExist(b_bjb_dto, "B_RATIFYLOG_DTOs", "B_RATIFYLOG_DTO")){
//                    Map ratifylog_dtOs = (Map) b_bjb_dto.get("B_RATIFYLOG_DTOs");
//                    Map ratifylog_dto = (Map) ratifylog_dtOs.get("B_RATIFYLOG_DTO");
//                    B_RATIFYLOG ratifylog = JSON.parseObject(JSON.toJSONString(ratifylog_dto), B_RATIFYLOG.class);
//                    ratifylogs.add(ratifylog);
//                }
//
//                B_JSXM b_jsxm = JSON.parseObject(JSON.toJSONString(b_jsxm_dto), B_JSXM.class);
//                B_BJB b_bjb = JSON.parseObject(JSON.toJSONString(b_bjb_dto), B_BJB.class);
//                bjbList.add(b_bjb);
//                jsxmList.add(b_jsxm);
//            }
//            // 数据入库
//            if (!CollectionUtils.isEmpty(jsxmList)) {
//                jsxmService.saveAll(jsxmList);
//            }
//            if (!CollectionUtils.isEmpty(jsxmXzqbmList)) {
//                jsxm_xzqbmService.saveAll(jsxmXzqbmList);
//            }
//            if (!CollectionUtils.isEmpty(zbgxList)) {
//                zbgxService.saveAll(zbgxList);
//            }
//            if (!CollectionUtils.isEmpty(bjbList)) {
//                bjbService.saveAll(bjbList);
//            }
//            if (!CollectionUtils.isEmpty(ratifylogs)) {
//                ratifylogService.saveAll(ratifylogs);
//            }
//            if (!CollectionUtils.isEmpty(zbgxgzs)) {
//                zbgxgzService.saveAll(zbgxgzs);
//            }
//            if (!CollectionUtils.isEmpty(zbhxes)) {
//                zbhxService.saveAll(zbhxes);
//            }
//            if (!CollectionUtils.isEmpty(zbcnhxes)) {
//                zbcnhxService.saveAll(zbcnhxes);
//            }
//            if (!CollectionUtils.isEmpty(zbcndxes)) {
//                zbcndxService.saveAll(zbcndxes);
//            }
//
//            System.out.println(String.format("[B_JSXM]导入数据%s条", jsxmList.size()));
//            System.out.println(String.format("[B_JSXM_XZQBM]导入数据%s条", jsxmXzqbmList.size()));
//            System.out.println(String.format("[B_ZBGX]导入数据%s条", zbgxList.size()));
//            System.out.println(String.format("[B_BJB]导入数据%s条", bjbList.size()));
//            System.out.println(String.format("[B_B_RATIFYLOG]导入数据%s条", ratifylogs.size()));
//            System.out.println(String.format("[B_ZBGXGZ]导入数据%s条", zbgxgzs.size()));
//            System.out.println(String.format("[B_ZBHX]导入数据%s条", zbhxes.size()));
//            System.out.println(String.format("[B_ZBCNHX]导入数据%s条", zbcnhxes.size()));
//            System.out.println(String.format("[B_ZBCNDX]导入数据%s条", zbcndxes.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.7、导入指标预警阀值")
//    @GetMapping("/warning")
//    public String ImportIndexEarlyWarningThresholds(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取数据
//        String xmlContent = client.exportZBYJ(username, password, xzqdm, year);
//        if (xmlContent.substring(0,1).equalsIgnoreCase(":")){
//            System.out.println(String.format("[导出指标预警阀值]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出指标预警阀值]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        try {
//            List<Map<String, Object>> zbyjData = XmlParserUtils.getDataNoPrefix(xmlContent, "ZBYJObjects", "ZBYJObject");
//            if (CollectionUtils.isEmpty(zbyjData)){
//                    return "XML数据解析失败！";
//                }
//            List<B_ZBYJ> b_zbyjs = JSON.parseArray(JSON.toJSONString(zbyjData), B_ZBYJ.class);
//
//            if (!CollectionUtils.isEmpty(b_zbyjs)){
//                zbyjService.saveAll(b_zbyjs);
//            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.8、导入国家统筹下放指标  - 停用")
//    @GetMapping("/countriesAsWholeIndex")
//    public String countriesAsWholeIndex(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取数据
//        String xmlContent = client.exportGJTCXF(username, password, xzqdm, lastTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            // 写代码的时候，没数据，不太确定导入能否成功
//            System.out.println(String.format("[导出国家统筹下放指标]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出国家统筹下放指标]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        try {
//            List<Map<String, Object>> list = XmlParserUtils.getDataNoPrefix(xmlContent, "ZBTJObjects", "ZBTJObject");
//            if (CollectionUtils.isEmpty(list)){
//                return "XML数据解析失败！";
//            }
//            List<B_ZBTJ> objectList = JSON.parseArray(JSON.toJSONString(list), B_ZBTJ.class);
//            System.out.println(objectList);
//            if (!CollectionUtils.isEmpty(objectList)){
//                zbtjService.saveAll(objectList);
//            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.9、导入其它指标")
//    @GetMapping("/otherindex")
//    public String otherindex(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取数据
//        String xmlContent = client.exportQTZB(username, password, xzqdm, lastTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            // 写代码的时候，没数据，不太确定导入能否成功
//            System.out.println(String.format("[导出其它指标]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出其它指标]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        try {
//            List<Map<String, Object>> list = XmlParserUtils.getDataNoPrefix(xmlContent, "ZBQTObjects", "ZBQTObject");
//            if (CollectionUtils.isEmpty(list)){
//                return "XML数据解析失败！";
//            }
//            List<B_ZBQT> objectList = JSON.parseArray(JSON.toJSONString(list), B_ZBQT.class);
//            System.out.println(objectList);
//            if (!CollectionUtils.isEmpty(objectList)){
//                zbqtService.saveAll(objectList);
//            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.11、导入国家统筹申请情况指标  - 停用")
//    @GetMapping("/countriesAsWholeApplication")
//    public String CountriesAsWholeApplication(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取前置信息 - 申请单号
//        String prefix = client.exportGJTCList(username, password, xzqdm, lastTime);
//        // 对原始结果进行处理
//        String xmlContent = XmlParserUtils.getXMLContent(prefix);
//        if (xmlContent.substring(0,1).equalsIgnoreCase(":")){
//            System.out.println(String.format("[导出国家统筹申请情况指标]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出指标预警阀值]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        // 生成临时文件地址
//        String filename = UUID.randomUUID().toString();
//        String url = XmlParserUtils.generateFile(xmlContent, basePath, filename, ".xml");
//
//        // TODO 王晓东说这里面没湖北的数据，加上接口（获取申请号）的数据获取不到，就没写了
//        // TODO 这个接口涉及到2张表 B_GJTCORDER和 B_GJTCITEMS
//        // TODO 以下入库过程无数据验证
//        // 创建结果集列表
//        ArrayList<B_GJTCORDER> gjtcorders = new ArrayList<>();
//        ArrayList<B_GJTCITEMS> gjtcitems = new ArrayList<>();
//        try {
//            // 从生成的xml文件中获取数据 - 结束后会删除缓存文件
//            ArrayList<String> applyNoList = XmlParserUtils.getParameterPrefix(url,"GJTCBASIC_DTOs","OR_NO");
//            for (String applyNo: applyNoList){
//                // 根据申请单号，获取对应的国家统筹申请指标情况
//                String data = client.exportGJTCMX(username, password, xzqdm, applyNo);
//                Map jsxmData = XmlParserUtils.getJSXMData(data, "gjtcorder",
//                        "gjtcorder",
//                        "B_GJTCITEMS_DTOs");
//                // 获取项目信息数据
//                Map<String, Object> gjtcorder = (Map) jsxmData.get("gjtcorder");
//
//                // 获取项目信息中的子类数据 - gjtcorders
//                if (isValueExist(gjtcorder, "B_GJTCITEMS_DTOs", "B_GJTCITEMS_DTO")){
//                    Map dtOs = (Map) gjtcorder.get("B_GJTCITEMS_DTOs");
//                    Map dto = (Map) dtOs.get("B_GJTCITEMS_DTO");
//                    B_GJTCITEMS object = JSON.parseObject(JSON.toJSONString(dto), B_GJTCITEMS.class);
//                    gjtcitems.add(object);
//                }
//
//                B_GJTCORDER object = JSON.parseObject(JSON.toJSONString(gjtcorder), B_GJTCORDER.class);
//                gjtcorders.add(object);
//            }
//            // 数据入库
//            if (!CollectionUtils.isEmpty(gjtcorders)) {
//                gjtcorderService.saveAll(gjtcorders);
//            }
//            if (!CollectionUtils.isEmpty(gjtcitems)) {
//                gjtcitemsService.saveAll(gjtcitems);
//            }
//            System.out.println(String.format("[B_GJTCORDER]导入数据%s条", gjtcorders.size()));
//            System.out.println(String.format("[B_GJTCITEMS]导入数据%s条", gjtcitems.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.12、根据用户行政区代码导入指标库冻结数据")
//    @GetMapping("/frozendata")
//    public String frozendata(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取数据
//        String xmlContent = client.exportZBDJ(username, password, xzqdm);
//        if (xmlContent.substring(0,3).contains(":")){
//            // 写代码的时候(2021/08/09)，没数据，不太确定导入能否成功
//            System.out.println(String.format("[导出其它指标]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出其它指标]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        try {
//            List<Map<String, Object>> list = XmlParserUtils.getDataNoPrefix(xmlContent, "ZBDJObjects", "ZBDJObject");
//            if (CollectionUtils.isEmpty(list)){
//                return "XML数据解析失败！";
//            }
//            List<B_ZBDJ> objectList = JSON.parseArray(JSON.toJSONString(list), B_ZBDJ.class);
//            System.out.println(objectList);
//            if (!CollectionUtils.isEmpty(objectList)){
//                zbdjService.saveAll(objectList);
//            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.15、导入备案项目信息")
//    @GetMapping("/recordProject")
//    public String recordProject(){
//        // 引入第三方服务客户端
//        DataExportServiceSoap client = new DataExportService().getDataExportServiceSoap();
//        // 调用接口获取前置信息 - 备案编号
//        String JSXMByTime = client.exportBAXMBasic(username, password, xzqdm);
//        // 对原始结果进行处理
//        String xmlContent = XmlParserUtils.getXMLContent(JSXMByTime);
//        if (xmlContent.substring(0,1).equalsIgnoreCase(":")){
//            System.out.println(String.format("[导出所有备案项目基本信息 string]接口获取数据失败，数据为：" + xmlContent));
//            return String.format("[导出所有备案项目基本信息]接口获取数据失败，数据为：[%s]", xmlContent);
//        }
//        // 生成临时文件地址
//        String filename = UUID.randomUUID().toString();
//        String url = XmlParserUtils.generateFile(xmlContent, basePath, filename, ".xml");
//        // 创建结果集列表
//        ArrayList<HC_JDYS> jdysList = new ArrayList<>();
//        try {
//            // 从生成的xml文件中获取数据 - 结束后会删除缓存文件 - 数据很大，你忍一下（目前2500多），以下每次执行都有网络请求、IO、解析XML、数据转换
//            ArrayList<String> babhList = XmlParserUtils.getParameterPrefix(url,"HCYSBASICs","XMBH");
//            // 获取机器的逻辑核心数
//            int i = Runtime.getRuntime().availableProcessors();
//            ExecutorService executorService = Executors.newFixedThreadPool(i <= 5 ? 10 : 2*i);
//            for (String babh: babhList){
//                executorService.submit(() -> {
//                  try {
//                      long startTime = System.currentTimeMillis();
//                      System.out.println(String.format("线程[%s]开始执行...",Thread.currentThread().getName()));
//                      // 根据备案编号，获取对应的项目信息
//                      byte[] zip = client.exportBAXM(username, password, xzqdm, babh, "1");
//                      String zipFileName = String.format("%s%s",UUID.randomUUID().toString(), ".zip");
//                      // 根据字节数组生成zip文件
//                      FileUtil.generalFile(zip, basePath, zipFileName);
//                      String result = FileUtil.readFromZipWithPassword(basePath + File.separator + zipFileName, "1");
//                      // 读取结果后，删除缓存zip文件
//                      FileUtil.deleteCacheFile(basePath + File.separator + zipFileName);
//                      Map data = XmlParserUtils.getJSXMData(XmlParserUtils.getXMLContent(result), "HCYSDataPackage",
//                              "HC_JDYS_DTO", null);
//                      HC_JDYS hc_jdys = JSON.parseObject(JSON.toJSONString(data), HC_JDYS.class);
//                      jdysList.add(hc_jdys);
//                      jdysService.save(hc_jdys);
//                      System.out.println(String.format("线程[%s]执行结束，当前导入或更新数据为%s条",Thread.currentThread().getName(), jdysList.size()));
//                      long endTime = System.currentTimeMillis();
//                      System.out.println(String.format("线程[%s]耗时：%sms",Thread.currentThread().getName(), (endTime - startTime)));
//                  } catch (Exception e){
//                      e.printStackTrace();
//                  }
//                });
//            }
//            while (true){
//                if (executorService.isTerminated()){
////                    if (!CollectionUtils.isEmpty(jdysList)){
////                        jdysService.saveAll(jdysList);
////                    }
//                    System.out.println(String.format("任务全部执行完成！[HC_JDYS]导入数据%s条", jdysList.size()));
//                }
//            }
//        }catch (IOException e){
//            e.printStackTrace();
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//        return "数据信息正在导入！";
//    }
//
//    @ApiOperation("2.16、导入已删除建设项目列表")
//    @GetMapping("/deletedproject")
//    public CommonResult deletedproject(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListBySCXMLOG(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出已删除建设项目列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出已删除建设项目列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_SCXMLOG> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_SCXMLOG.class);
//            if (!CollectionUtils.isEmpty(objectList)){
//                scxmlogService.saveAll(objectList);
//            }
//            System.out.println(String.format("[B_SCXMLOG]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.17、导入授权指标明细列表 - 表外键原因无法导入")
//    @GetMapping("/authorizationIndicatorDetail")
//    public CommonResult authorizationIndicatorDetail(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListBySQMX(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出授权指标明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出授权指标明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_SQMX> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_SQMX.class);
//            if (!CollectionUtils.isEmpty(objectList)){
//                List<B_SQMX> rootList = getRootList(objectList);
//                if (!CollectionUtils.isEmpty(rootList)){
//                    Collections.reverse(rootList);
//                    sqmxService.saveAll(rootList);
//                }
////                sqmxService.saveAll(objectList);
//            }
//            System.out.println(String.format("[B_SQMX]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.18、导入授权改造指标明细列表 - 表外键原因无法导入")
//    @GetMapping("/authorizationModificationIndicatorsDetail")
//    public CommonResult authorizationModificationIndicatorsDetail(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListBySQMXGZ(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出授权改造指标明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出授权改造指标明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_SQMXGZ> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_SQMXGZ.class);
//            System.out.println(objectList);
////            if (!CollectionUtils.isEmpty(objectList)){
////                sqmxService.saveAll(objectList);
////            }
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.19、导入指标承诺明细列表")
//    @GetMapping("/indexPromisedDetail")
//    public CommonResult indexPromisedDetail(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListByZBCN(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出指标承诺明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出指标承诺明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_ZBCN> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_ZBCN.class);
//            System.out.println(objectList);
//            if (!CollectionUtils.isEmpty(objectList)){
//                zbcnService.saveAll(objectList);
//            }
//            System.out.println(String.format("[B_SQMX]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.20、导入指标出入库记录明细列表")
//    @GetMapping("/indicatorsForRecord")
//    public CommonResult indicatorsForRecord(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListByZBCRKJL(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出指标出入库记录明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出指标出入库记录明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_ZBCRKJL> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_ZBCRKJL.class);
//            System.out.println(objectList);
////            if (!CollectionUtils.isEmpty(objectList)){
////                zbcnService.saveAll(objectList);
////            }
//            System.out.println(String.format("[B_ZBCRKJL]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.21、导入指标冻结明细列表 - 失败:未检索到任何数据！")
//    @GetMapping("/frozenDataDetail")
//    public CommonResult frozenDataDetail(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListByZBDJ(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出指标冻结明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出指标冻结明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_ZBDJ> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_ZBDJ.class);
//            System.out.println(objectList);
////            if (!CollectionUtils.isEmpty(objectList)){
////                zbcnService.saveAll(objectList);
////            }
//            System.out.println(String.format("[B_ZBDJ]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//    @ApiOperation("2.22、导入指标核实明细列表 - 失败:未检索到任何数据！")
//    @GetMapping("/indicatorsToVerify")
//    public CommonResult indicatorsToVerify(){
//        // 引入第三方服务客户端
//        DataExportService2Soap client = new DataExportService2().getDataExportService2Soap();
//        // 调用接口获取数据
//        String xmlContent = client.exportListByZBHS(username, password, xzqdm, startTime, endTime);
//        if (xmlContent.substring(0,3).contains(":")){
//            System.out.println(String.format("[导出指标冻结明细列表]接口获取数据失败，数据为：" + xmlContent));
//            return CommonResult.error(String.format("[导出指标冻结明细列表]接口获取数据失败，数据为：[%s]", xmlContent));
//        }
//        try {
////            xmlContent = XmlParserUtils.getXMLContent(xmlContent);
//            Map<String, Object> data = XmlParserUtils.getDataList(xmlContent, "DataPackage","ExecResult,DataList", "Data");
//            if (CollectionUtils.isEmpty(data)){
//                return CommonResult.error("XML数据解析失败！");
//            }
//            // 判断是否获取成功
//            if (data.get("ExecResult") != null){
//                Map<String, String> map = (Map<String, String>) data.get("ExecResult");
//                String result = map.get("result");
//                String message = map.get("message");
//
//                if (!"true".equalsIgnoreCase(result)){
//                    System.out.println(String.format("数据获取失败，详细信息：[%s]", message));
//                    return CommonResult.error(String.format("数据获取失败，详细信息：[%s]", message));
//
//                }
//            }
//            // 确认获取成功后，提取数据
//            List<Map<String, Object>> dataList = (List<Map<String, Object>>) data.get("DataList");
//            List<B_ZBHS> objectList = JSON.parseArray(JSON.toJSONString(dataList), B_ZBHS.class);
//            System.out.println(objectList);
////            if (!CollectionUtils.isEmpty(objectList)){
////                zbcnService.saveAll(objectList);
////            }
//            System.out.println(String.format("[B_ZBHS]导入数据%s条", objectList.size()));
//        } catch (Exception e){
//            e.printStackTrace();
//        }
//        return CommonResult.success("数据信息正在导入！");
//    }
//
//
//    /**
//     * 获取数据根节点
//     * @param dataList
//     * @return
//     */
//    private static List<B_SQMX> getRootList(List<B_SQMX> dataList){
//        Collections.sort(dataList, new Comparator<B_SQMX>() {
//            @Override
//            public int compare(B_SQMX o1, B_SQMX o2) {
//                Date time1 = o1.getSQMX_LRSJ();
//                Date time2 = o2.getSQMX_LRSJ();
//                return time1.compareTo(time2);
//            }
//        });
//       return dataList;
//    }
//
//    /**
//     * 检查对应节点下是否存在数据
//     * @param map
//     * @param dtosName
//     * @param dtoName
//     * @return
//     */
//    private static boolean isValueExist(Map<String, Object> map, String dtosName, String dtoName){
//        if (map != null && map.get(dtosName) != null){
//            if (StringUtils.isNotBlank(map.get(dtosName).toString())){
//                Map dtos = (Map) map.get(dtosName);
//                if (dtos != null && dtos.get(dtoName) != null){
//                    return true;
//                }
//            }
//        }
//        return false;
//    }
//
//    private static String generalFile(String str){
//        System.out.println("执行了生成方法");
//        String fileUrl = "D:\\program\\work\\hbdata\\1.xml";
//        try {
// BufferedWriter writer = new BufferedWriter (new OutputStreamWriter(new FileOutputStream (fileUrl),"UTF-8"));
//            writer.write(str);
//            writer.flush();
//            writer.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//        return fileUrl;
//    }
//}
